//base
function loadGltf1(){
    var scene = viewer.scene;
    var modelMatrix = Cesium.Transforms.eastNorthUpToFixedFrame(
        Cesium.Cartesian3.fromDegrees(116.398015, 39.988201, 1.0));        //gltf数据加载位置
//116.398015-116.397755=0.00026,39.988201-39.988051=0.00015,
    var model = scene.primitives.add(Cesium.Model.fromGltf({
        url: 'http://localhost:9082/gltf/ID_2.gltf',        //如果为bgltf则为.bgltf
        modelMatrix: modelMatrix
        //scale : 3.0     //放大倍数
    }));
    var m = model.modelMatrix;
//构建一个三阶旋转矩阵。模型旋转一定的角度，fromRotation[Z]来控制旋转轴，toRadians()为旋转角度，转为弧度再参与运算
    var m1 = Cesium.Matrix3.fromRotationZ(Cesium.Math.toRadians(-105));

//矩阵计算
    Cesium.Matrix4.multiplyByMatrix3(m, m1, m);
//将计算结果再赋值给modelMatrix
    model.modelMatrix = m;


//3
    modelMatrix = Cesium.Transforms.eastNorthUpToFixedFrame(
        Cesium.Cartesian3.fromDegrees(116.399228, 39.988685, 1.0));        //gltf数据加载位置
//Cesium.Cartesian3.fromDegrees(116.399228, 39.988685, 1.0));        //gltf数据加载位置

    model = scene.primitives.add(Cesium.Model.fromGltf({
        url: 'http://localhost:9082/gltf/ID_3.gltf',        //如果为bgltf则为.bgltf
        modelMatrix: modelMatrix
        //scale : 3.0     //放大倍数
    }));
    m = model.modelMatrix;
//构建一个三阶旋转矩阵。模型旋转一定的角度，fromRotation[Z]来控制旋转轴，toRadians()为旋转角度，转为弧度再参与运算
    m1 = Cesium.Matrix3.fromRotationZ(Cesium.Math.toRadians(-105));
//矩阵计算
    Cesium.Matrix4.multiplyByMatrix3(m, m1, m);
//将计算结果再赋值给modelMatrix
    model.modelMatrix = m;


//5
    modelMatrix = Cesium.Transforms.eastNorthUpToFixedFrame(
        Cesium.Cartesian3.fromDegrees(116.395804, 39.989626, 1.0));        //gltf数据加载位置

    model = scene.primitives.add(Cesium.Model.fromGltf({
        url: 'http://localhost:9082/gltf/ID_5.gltf',        //如果为bgltf则为.bgltf
        modelMatrix: modelMatrix
        //scale : 3.0     //放大倍数
    }));
    m = model.modelMatrix;
//构建一个三阶旋转矩阵。模型旋转一定的角度，fromRotation[Z]来控制旋转轴，toRadians()为旋转角度，转为弧度再参与运算
    m1 = Cesium.Matrix3.fromRotationZ(Cesium.Math.toRadians(-105));
//矩阵计算
    Cesium.Matrix4.multiplyByMatrix3(m, m1, m);
//将计算结果再赋值给modelMatrix
    model.modelMatrix = m;

//6
    modelMatrix = Cesium.Transforms.eastNorthUpToFixedFrame(
        Cesium.Cartesian3.fromDegrees(116.397813, 39.992714, 1.0));        //gltf数据加载位置

    model = scene.primitives.add(Cesium.Model.fromGltf({
        url: 'http://localhost:9082/gltf/ID_6.gltf',        //如果为bgltf则为.bgltf
        modelMatrix: modelMatrix
        //scale : 3.0     //放大倍数
    }));
    m = model.modelMatrix;
//构建一个三阶旋转矩阵。模型旋转一定的角度，fromRotation[Z]来控制旋转轴，toRadians()为旋转角度，转为弧度再参与运算
    m1 = Cesium.Matrix3.fromRotationZ(Cesium.Math.toRadians(-105));
//矩阵计算
    Cesium.Matrix4.multiplyByMatrix3(m, m1, m);
//将计算结果再赋值给modelMatrix
    model.modelMatrix = m;


//8
    modelMatrix = Cesium.Transforms.eastNorthUpToFixedFrame(
        Cesium.Cartesian3.fromDegrees(116.398474, 39.992576, 1.0));        //gltf数据加载位置

    model = scene.primitives.add(Cesium.Model.fromGltf({
        url: 'http://localhost:9082/gltf/ID_8.gltf',        //如果为bgltf则为.bgltf
        modelMatrix: modelMatrix
        //scale : 3.0     //放大倍数
    }));
    m = model.modelMatrix;
//构建一个三阶旋转矩阵。模型旋转一定的角度，fromRotation[Z]来控制旋转轴，toRadians()为旋转角度，转为弧度再参与运算
    m1 = Cesium.Matrix3.fromRotationZ(Cesium.Math.toRadians(-105));
//矩阵计算
    Cesium.Matrix4.multiplyByMatrix3(m, m1, m);
//将计算结果再赋值给modelMatrix
    model.modelMatrix = m;

//9
    modelMatrix = Cesium.Transforms.eastNorthUpToFixedFrame(
        Cesium.Cartesian3.fromDegrees(116.398936, 39.992281, 1.0));        //gltf数据加载位置

    model = scene.primitives.add(Cesium.Model.fromGltf({
        url: 'http://localhost:9082/gltf/ID_9.gltf',        //如果为bgltf则为.bgltf
        modelMatrix: modelMatrix
        //scale : 3.0     //放大倍数
    }));
    m = model.modelMatrix;
//构建一个三阶旋转矩阵。模型旋转一定的角度，fromRotation[Z]来控制旋转轴，toRadians()为旋转角度，转为弧度再参与运算
    m1 = Cesium.Matrix3.fromRotationZ(Cesium.Math.toRadians(-105));
//矩阵计算
    Cesium.Matrix4.multiplyByMatrix3(m, m1, m);
//将计算结果再赋值给modelMatrix
    model.modelMatrix = m;


//10
    modelMatrix = Cesium.Transforms.eastNorthUpToFixedFrame(
        Cesium.Cartesian3.fromDegrees(116.39931, 39.991913, 1.0));        //gltf数据加载位置

    model = scene.primitives.add(Cesium.Model.fromGltf({
        url: 'http://localhost:9082/gltf/ID_10.gltf',        //如果为bgltf则为.bgltf
        modelMatrix: modelMatrix
        //scale : 3.0     //放大倍数
    }));
    m = model.modelMatrix;
//构建一个三阶旋转矩阵。模型旋转一定的角度，fromRotation[Z]来控制旋转轴，toRadians()为旋转角度，转为弧度再参与运算
    m1 = Cesium.Matrix3.fromRotationZ(Cesium.Math.toRadians(-105));
//矩阵计算
    Cesium.Matrix4.multiplyByMatrix3(m, m1, m);
//将计算结果再赋值给modelMatrix
    model.modelMatrix = m;

//11
    modelMatrix = Cesium.Transforms.eastNorthUpToFixedFrame(
        Cesium.Cartesian3.fromDegrees(116.399717, 39.991446, 1.0));        //gltf数据加载位置

    model = scene.primitives.add(Cesium.Model.fromGltf({
        url: 'http://localhost:9082/gltf/ID_11.gltf',        //如果为bgltf则为.bgltf
        modelMatrix: modelMatrix
        //scale : 3.0     //放大倍数
    }));
    m = model.modelMatrix;
//构建一个三阶旋转矩阵。模型旋转一定的角度，fromRotation[Z]来控制旋转轴，toRadians()为旋转角度，转为弧度再参与运算
    m1 = Cesium.Matrix3.fromRotationZ(Cesium.Math.toRadians(-105));
//矩阵计算
    Cesium.Matrix4.multiplyByMatrix3(m, m1, m);
//将计算结果再赋值给modelMatrix
    model.modelMatrix = m;

//12
    modelMatrix = Cesium.Transforms.eastNorthUpToFixedFrame(
        Cesium.Cartesian3.fromDegrees(116.396779, 39.991721, 1.0));        //gltf数据加载位置

    model = scene.primitives.add(Cesium.Model.fromGltf({
        url: 'http://localhost:9082/gltf/ID_12.gltf',        //如果为bgltf则为.bgltf
        modelMatrix: modelMatrix
        //scale : 3.0     //放大倍数
    }));
    m = model.modelMatrix;
//构建一个三阶旋转矩阵。模型旋转一定的角度，fromRotation[Z]来控制旋转轴，toRadians()为旋转角度，转为弧度再参与运算
    m1 = Cesium.Matrix3.fromRotationZ(Cesium.Math.toRadians(-105));
//矩阵计算
    Cesium.Matrix4.multiplyByMatrix3(m, m1, m);
//将计算结果再赋值给modelMatrix
    model.modelMatrix = m;

//14
    modelMatrix = Cesium.Transforms.eastNorthUpToFixedFrame(
        Cesium.Cartesian3.fromDegrees(116.396313, 39.993146, 1.0));        //gltf数据加载位置

    model = scene.primitives.add(Cesium.Model.fromGltf({
        url: 'http://localhost:9082/gltf/ID_14.gltf',        //如果为bgltf则为.bgltf
        modelMatrix: modelMatrix
        //scale : 3.0     //放大倍数
    }));
    m = model.modelMatrix;
//构建一个三阶旋转矩阵。模型旋转一定的角度，fromRotation[Z]来控制旋转轴，toRadians()为旋转角度，转为弧度再参与运算
    m1 = Cesium.Matrix3.fromRotationZ(Cesium.Math.toRadians(-105));
//矩阵计算
    Cesium.Matrix4.multiplyByMatrix3(m, m1, m);
//将计算结果再赋值给modelMatrix
    model.modelMatrix = m;

//15
    modelMatrix = Cesium.Transforms.eastNorthUpToFixedFrame(
        Cesium.Cartesian3.fromDegrees(116.395417, 39.991552, 1.0));        //gltf数据加载位置

    model = scene.primitives.add(Cesium.Model.fromGltf({
        url: 'http://localhost:9082/gltf/ID_15.gltf',        //如果为bgltf则为.bgltf
        modelMatrix: modelMatrix
        //scale : 3.0     //放大倍数
    }));
    m = model.modelMatrix;
//构建一个三阶旋转矩阵。模型旋转一定的角度，fromRotation[Z]来控制旋转轴，toRadians()为旋转角度，转为弧度再参与运算
    m1 = Cesium.Matrix3.fromRotationZ(Cesium.Math.toRadians(-105));
//矩阵计算
    Cesium.Matrix4.multiplyByMatrix3(m, m1, m);
//将计算结果再赋值给modelMatrix
    model.modelMatrix = m;

//16
    modelMatrix = Cesium.Transforms.eastNorthUpToFixedFrame(
        Cesium.Cartesian3.fromDegrees(116.396298, 39.992604, 1.0));        //gltf数据加载位置

    model = scene.primitives.add(Cesium.Model.fromGltf({
        url: 'http://localhost:9082/gltf/ID_16.gltf',        //如果为bgltf则为.bgltf
        modelMatrix: modelMatrix
        //scale : 3.0     //放大倍数
    }));
    m = model.modelMatrix;
//构建一个三阶旋转矩阵。模型旋转一定的角度，fromRotation[Z]来控制旋转轴，toRadians()为旋转角度，转为弧度再参与运算
    m1 = Cesium.Matrix3.fromRotationZ(Cesium.Math.toRadians(-105));
//矩阵计算
    Cesium.Matrix4.multiplyByMatrix3(m, m1, m);
//将计算结果再赋值给modelMatrix
    model.modelMatrix = m;

//18
    modelMatrix = Cesium.Transforms.eastNorthUpToFixedFrame(
        Cesium.Cartesian3.fromDegrees(116.395999, 39.991158, 1.0));        //gltf数据加载位置

    model = scene.primitives.add(Cesium.Model.fromGltf({
        url: 'http://localhost:9082/gltf/ID_18.gltf',        //如果为bgltf则为.bgltf
        modelMatrix: modelMatrix
        //scale : 3.0     //放大倍数
    }));
    m = model.modelMatrix;
//构建一个三阶旋转矩阵。模型旋转一定的角度，fromRotation[Z]来控制旋转轴，toRadians()为旋转角度，转为弧度再参与运算
    m1 = Cesium.Matrix3.fromRotationZ(Cesium.Math.toRadians(-105));
//矩阵计算
    Cesium.Matrix4.multiplyByMatrix3(m, m1, m);
//将计算结果再赋值给modelMatrix
    model.modelMatrix = m;


//19
    modelMatrix = Cesium.Transforms.eastNorthUpToFixedFrame(
        Cesium.Cartesian3.fromDegrees(116.395499, 39.990915, 1.0));        //gltf数据加载位置

    model = scene.primitives.add(Cesium.Model.fromGltf({
        url: 'http://localhost:9082/gltf/ID_19.gltf',        //如果为bgltf则为.bgltf
        modelMatrix: modelMatrix
        //scale : 3.0     //放大倍数
    }));
    m = model.modelMatrix;
//构建一个三阶旋转矩阵。模型旋转一定的角度，fromRotation[Z]来控制旋转轴，toRadians()为旋转角度，转为弧度再参与运算
    m1 = Cesium.Matrix3.fromRotationZ(Cesium.Math.toRadians(-105));
//矩阵计算
    Cesium.Matrix4.multiplyByMatrix3(m, m1, m);
//将计算结果再赋值给modelMatrix
    model.modelMatrix = m;

//20
    modelMatrix = Cesium.Transforms.eastNorthUpToFixedFrame(
        Cesium.Cartesian3.fromDegrees(116.395956, 39.991825, 1.0));        //gltf数据加载位置

    model = scene.primitives.add(Cesium.Model.fromGltf({
        url: 'http://localhost:9082/gltf/ID_20.gltf',        //如果为bgltf则为.bgltf
        modelMatrix: modelMatrix
        //scale : 3.0     //放大倍数
    }));
    m = model.modelMatrix;
//构建一个三阶旋转矩阵。模型旋转一定的角度，fromRotation[Z]来控制旋转轴，toRadians()为旋转角度，转为弧度再参与运算
    m1 = Cesium.Matrix3.fromRotationZ(Cesium.Math.toRadians(-105));
//矩阵计算
    Cesium.Matrix4.multiplyByMatrix3(m, m1, m);
//将计算结果再赋值给modelMatrix
    model.modelMatrix = m;

//21
    modelMatrix = Cesium.Transforms.eastNorthUpToFixedFrame(
        Cesium.Cartesian3.fromDegrees(116.396801, 39.991119, 1.0));        //gltf数据加载位置

    model = scene.primitives.add(Cesium.Model.fromGltf({
        url: 'http://localhost:9082/gltf/ID_21.gltf',        //如果为bgltf则为.bgltf
        modelMatrix: modelMatrix
        //scale : 3.0     //放大倍数
    }));
    m = model.modelMatrix;
//构建一个三阶旋转矩阵。模型旋转一定的角度，fromRotation[Z]来控制旋转轴，toRadians()为旋转角度，转为弧度再参与运算
    m1 = Cesium.Matrix3.fromRotationZ(Cesium.Math.toRadians(-105));
//矩阵计算
    Cesium.Matrix4.multiplyByMatrix3(m, m1, m);
//将计算结果再赋值给modelMatrix
    model.modelMatrix = m;

//37
    modelMatrix = Cesium.Transforms.eastNorthUpToFixedFrame(
        Cesium.Cartesian3.fromDegrees(116.394054, 39.991551, 1.0));        //gltf数据加载位置

    model = scene.primitives.add(Cesium.Model.fromGltf({
        url: 'http://localhost:9082/gltf/ID_37.gltf',        //如果为bgltf则为.bgltf
        modelMatrix: modelMatrix
        //scale : 3.0     //放大倍数
    }));
    m = model.modelMatrix;
//构建一个三阶旋转矩阵。模型旋转一定的角度，fromRotation[Z]来控制旋转轴，toRadians()为旋转角度，转为弧度再参与运算
    m1 = Cesium.Matrix3.fromRotationZ(Cesium.Math.toRadians(-105));
//矩阵计算
    Cesium.Matrix4.multiplyByMatrix3(m, m1, m);
//将计算结果再赋值给modelMatrix
    model.modelMatrix = m;


//39
    modelMatrix = Cesium.Transforms.eastNorthUpToFixedFrame(
        Cesium.Cartesian3.fromDegrees(116.39649, 39.99042, 1.0));        //gltf数据加载位置

    model = scene.primitives.add(Cesium.Model.fromGltf({
        url: 'http://localhost:9082/gltf/ID_39.gltf',        //如果为bgltf则为.bgltf
        modelMatrix: modelMatrix
        //scale : 3.0     //放大倍数
    }));
    m = model.modelMatrix;
//构建一个三阶旋转矩阵。模型旋转一定的角度，fromRotation[Z]来控制旋转轴，toRadians()为旋转角度，转为弧度再参与运算
    m1 = Cesium.Matrix3.fromRotationZ(Cesium.Math.toRadians(-105));
//矩阵计算
    Cesium.Matrix4.multiplyByMatrix3(m, m1, m);
//将计算结果再赋值给modelMatrix
    model.modelMatrix = m;

//40
    modelMatrix = Cesium.Transforms.eastNorthUpToFixedFrame(
        Cesium.Cartesian3.fromDegrees(116.396623, 39.989904, 1.0));        //gltf数据加载位置

    model = scene.primitives.add(Cesium.Model.fromGltf({
        url: 'http://localhost:9082/gltf/ID_40.gltf',        //如果为bgltf则为.bgltf
        modelMatrix: modelMatrix
        //scale : 3.0     //放大倍数
    }));
    m = model.modelMatrix;
//构建一个三阶旋转矩阵。模型旋转一定的角度，fromRotation[Z]来控制旋转轴，toRadians()为旋转角度，转为弧度再参与运算
    m1 = Cesium.Matrix3.fromRotationZ(Cesium.Math.toRadians(-105));
//矩阵计算
    Cesium.Matrix4.multiplyByMatrix3(m, m1, m);
//将计算结果再赋值给modelMatrix
    model.modelMatrix = m;

//42
    modelMatrix = Cesium.Transforms.eastNorthUpToFixedFrame(
        Cesium.Cartesian3.fromDegrees(116.400436, 39.990006, 1.0));        //gltf数据加载位置

    model = scene.primitives.add(Cesium.Model.fromGltf({
        url: 'http://localhost:9082/gltf/ID_42.gltf',        //如果为bgltf则为.bgltf
        modelMatrix: modelMatrix
        //scale : 3.0     //放大倍数
    }));
    m = model.modelMatrix;
//构建一个三阶旋转矩阵。模型旋转一定的角度，fromRotation[Z]来控制旋转轴，toRadians()为旋转角度，转为弧度再参与运算
    m1 = Cesium.Matrix3.fromRotationZ(Cesium.Math.toRadians(-105));
//矩阵计算
    Cesium.Matrix4.multiplyByMatrix3(m, m1, m);
//将计算结果再赋值给modelMatrix
    model.modelMatrix = m;


//43
    modelMatrix = Cesium.Transforms.eastNorthUpToFixedFrame(
        Cesium.Cartesian3.fromDegrees(116.393756, 39.992986, 1.0));        //gltf数据加载位置

    model = scene.primitives.add(Cesium.Model.fromGltf({
        url: 'http://localhost:9082/gltf/ID_43.gltf',        //如果为bgltf则为.bgltf
        modelMatrix: modelMatrix
        //scale : 3.0     //放大倍数
    }));
    m = model.modelMatrix;
//构建一个三阶旋转矩阵。模型旋转一定的角度，fromRotation[Z]来控制旋转轴，toRadians()为旋转角度，转为弧度再参与运算
    m1 = Cesium.Matrix3.fromRotationZ(Cesium.Math.toRadians(-105));
//矩阵计算
    Cesium.Matrix4.multiplyByMatrix3(m, m1, m);
//将计算结果再赋值给modelMatrix
    model.modelMatrix = m;

//44
    modelMatrix = Cesium.Transforms.eastNorthUpToFixedFrame(
        Cesium.Cartesian3.fromDegrees(116.39398, 39.989883, 1.0));        //gltf数据加载位置

    model = scene.primitives.add(Cesium.Model.fromGltf({
        url: 'http://localhost:9082/gltf/ID_44.gltf',        //如果为bgltf则为.bgltf
        modelMatrix: modelMatrix
        //scale : 3.0     //放大倍数
    }));
    m = model.modelMatrix;
//构建一个三阶旋转矩阵。模型旋转一定的角度，fromRotation[Z]来控制旋转轴，toRadians()为旋转角度，转为弧度再参与运算
    m1 = Cesium.Matrix3.fromRotationZ(Cesium.Math.toRadians(-105));
//矩阵计算
    Cesium.Matrix4.multiplyByMatrix3(m, m1, m);
//将计算结果再赋值给modelMatrix
    model.modelMatrix = m;

//45
    modelMatrix = Cesium.Transforms.eastNorthUpToFixedFrame(
        Cesium.Cartesian3.fromDegrees(116.398791, 39.994066, 1.0));        //gltf数据加载位置

    model = scene.primitives.add(Cesium.Model.fromGltf({
        url: 'http://localhost:9082/gltf/ID_45.gltf',        //如果为bgltf则为.bgltf
        modelMatrix: modelMatrix
        //scale : 3.0     //放大倍数
    }));
    m = model.modelMatrix;
//构建一个三阶旋转矩阵。模型旋转一定的角度，fromRotation[Z]来控制旋转轴，toRadians()为旋转角度，转为弧度再参与运算
    m1 = Cesium.Matrix3.fromRotationZ(Cesium.Math.toRadians(-105));
//矩阵计算
    Cesium.Matrix4.multiplyByMatrix3(m, m1, m);
//将计算结果再赋值给modelMatrix
    model.modelMatrix = m;

//46
    modelMatrix = Cesium.Transforms.eastNorthUpToFixedFrame(
        Cesium.Cartesian3.fromDegrees(116.399485, 39.994162, 1.0));        //gltf数据加载位置

    model = scene.primitives.add(Cesium.Model.fromGltf({
        url: 'http://localhost:9082/gltf/ID_46.gltf',        //如果为bgltf则为.bgltf
        modelMatrix: modelMatrix
        //scale : 3.0     //放大倍数
    }));
    m = model.modelMatrix;
//构建一个三阶旋转矩阵。模型旋转一定的角度，fromRotation[Z]来控制旋转轴，toRadians()为旋转角度，转为弧度再参与运算
    m1 = Cesium.Matrix3.fromRotationZ(Cesium.Math.toRadians(-105));
//矩阵计算
    Cesium.Matrix4.multiplyByMatrix3(m, m1, m);
//将计算结果再赋值给modelMatrix
    model.modelMatrix = m;

//47
    modelMatrix = Cesium.Transforms.eastNorthUpToFixedFrame(
        Cesium.Cartesian3.fromDegrees(116.396348, 39.994099, 1.0));        //gltf数据加载位置

    model = scene.primitives.add(Cesium.Model.fromGltf({
        url: 'http://localhost:9082/gltf/ID_47.gltf',        //如果为bgltf则为.bgltf
        modelMatrix: modelMatrix
        //scale : 3.0     //放大倍数
    }));
    m = model.modelMatrix;
//构建一个三阶旋转矩阵。模型旋转一定的角度，fromRotation[Z]来控制旋转轴，toRadians()为旋转角度，转为弧度再参与运算
    m1 = Cesium.Matrix3.fromRotationZ(Cesium.Math.toRadians(-105));
//矩阵计算
    Cesium.Matrix4.multiplyByMatrix3(m, m1, m);
//将计算结果再赋值给modelMatrix
    model.modelMatrix = m;

//48
    modelMatrix = Cesium.Transforms.eastNorthUpToFixedFrame(
        Cesium.Cartesian3.fromDegrees(116.39687, 39.994049, 1.0));        //gltf数据加载位置

    model = scene.primitives.add(Cesium.Model.fromGltf({
        url: 'http://localhost:9082/gltf/ID_48.gltf',        //如果为bgltf则为.bgltf
        modelMatrix: modelMatrix
        //scale : 3.0     //放大倍数
    }));
    m = model.modelMatrix;
//构建一个三阶旋转矩阵。模型旋转一定的角度，fromRotation[Z]来控制旋转轴，toRadians()为旋转角度，转为弧度再参与运算
    m1 = Cesium.Matrix3.fromRotationZ(Cesium.Math.toRadians(-105));
//矩阵计算
    Cesium.Matrix4.multiplyByMatrix3(m, m1, m);
//将计算结果再赋值给modelMatrix
    model.modelMatrix = m;

//49
    modelMatrix = Cesium.Transforms.eastNorthUpToFixedFrame(
        Cesium.Cartesian3.fromDegrees(116.397518, 39.994126, 1.0));        //gltf数据加载位置

    model = scene.primitives.add(Cesium.Model.fromGltf({
        url: 'http://localhost:9082/gltf/ID_49.gltf',        //如果为bgltf则为.bgltf
        modelMatrix: modelMatrix
        //scale : 3.0     //放大倍数
    }));
    m = model.modelMatrix;
//构建一个三阶旋转矩阵。模型旋转一定的角度，fromRotation[Z]来控制旋转轴，toRadians()为旋转角度，转为弧度再参与运算
    m1 = Cesium.Matrix3.fromRotationZ(Cesium.Math.toRadians(-105));
//矩阵计算
    Cesium.Matrix4.multiplyByMatrix3(m, m1, m);
//将计算结果再赋值给modelMatrix
    model.modelMatrix = m;

//50
    modelMatrix = Cesium.Transforms.eastNorthUpToFixedFrame(
        Cesium.Cartesian3.fromDegrees(116.398143, 39.994141, 1.0));        //gltf数据加载位置

    model = scene.primitives.add(Cesium.Model.fromGltf({
        url: 'http://localhost:9082/gltf/ID_50.gltf',        //如果为bgltf则为.bgltf
        modelMatrix: modelMatrix
        //scale : 3.0     //放大倍数
    }));
    m = model.modelMatrix;
//构建一个三阶旋转矩阵。模型旋转一定的角度，fromRotation[Z]来控制旋转轴，toRadians()为旋转角度，转为弧度再参与运算
    m1 = Cesium.Matrix3.fromRotationZ(Cesium.Math.toRadians(-105));
//矩阵计算
    Cesium.Matrix4.multiplyByMatrix3(m, m1, m);
//将计算结果再赋值给modelMatrix
    model.modelMatrix = m;

//149
    modelMatrix = Cesium.Transforms.eastNorthUpToFixedFrame(
        Cesium.Cartesian3.fromDegrees(116.40025, 39.988885, 1.0));        //gltf数据加载位置

    model = scene.primitives.add(Cesium.Model.fromGltf({
        url: 'http://localhost:9082/gltf/ID_149.gltf',        //如果为bgltf则为.bgltf
        modelMatrix: modelMatrix
        //scale : 3.0     //放大倍数
    }));
    m = model.modelMatrix;
//构建一个三阶旋转矩阵。模型旋转一定的角度，fromRotation[Z]来控制旋转轴，toRadians()为旋转角度，转为弧度再参与运算
    m1 = Cesium.Matrix3.fromRotationZ(Cesium.Math.toRadians(-105));
//矩阵计算
    Cesium.Matrix4.multiplyByMatrix3(m, m1, m);
//将计算结果再赋值给modelMatrix
    model.modelMatrix = m;
}